{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| hide\n",
    "#| eval: false\n",
    "! [ -e /content ] && pip install -Uqq fastai  # upgrade fastai on colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| default_exp vision.core\n",
    "#| default_cls_lvl 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "from __future__ import annotations\n",
    "from fastai.torch_basics import *\n",
    "from fastai.data.all import *\n",
    "\n",
    "from PIL import Image\n",
    "\n",
    "try: BILINEAR,NEAREST = Image.Resampling.BILINEAR,Image.Resampling.NEAREST\n",
    "except AttributeError: from PIL.Image import BILINEAR,NEAREST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "_all_ = ['BILINEAR','NEAREST']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai.data.external import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| hide\n",
    "from nbdev.showdoc import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "_all_ = ['Image','ToTensor']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| exporti\n",
    "@patch\n",
    "def __repr__(x:Image.Image):\n",
    "    return \"<%s.%s image mode=%s size=%dx%d>\" % (x.__class__.__module__, x.__class__.__name__, x.mode, x.size[0], x.size[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Core vision\n",
    "\n",
    "> Basic image opening/processing functionality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helpers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "imagenet_stats = ([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "cifar_stats    = ([0.491, 0.482, 0.447], [0.247, 0.243, 0.261])\n",
    "mnist_stats    = ([0.131], [0.308])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = Image.open(TEST_IMAGE).resize((30,20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "if not hasattr(Image,'_patched'):\n",
    "    _old_sz = Image.Image.size.fget\n",
    "    @patch(as_prop=True)\n",
    "    def size(x:Image.Image): return fastuple(_old_sz(x))\n",
    "    Image._patched = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "@patch(as_prop=True)\n",
    "def n_px(x: Image.Image): return x.size[0] * x.size[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.n_px, 30*20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "@patch(as_prop=True)\n",
    "def shape(x: Image.Image): return x.size[1],x.size[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.shape, (20,30))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "@patch(as_prop=True)\n",
    "def aspect(x: Image.Image): return x.size[0]/x.size[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.aspect, 30/20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "@patch\n",
    "def reshape(x: Image.Image, h, w, resample=0):\n",
    "    \"`resize` `x` to `(w,h)`\"\n",
    "    return x.resize((w,h), resample=resample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "---\n",
       "\n",
       "#### Image.reshape\n",
       "\n",
       ">      Image.reshape (x:PIL.Image.Image, h, w, resample=0)\n",
       "\n",
       "`resize` `x` to `(w,h)`"
      ],
      "text/plain": [
       "<nbdev.showdoc.BasicMarkdownRenderer>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_doc(Image.Image.reshape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.reshape(12,10).shape, (12,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "@patch\n",
    "def to_bytes_format(im:Image.Image, format='png'):\n",
    "    \"Convert to bytes, default to PNG format\"\n",
    "    arr = io.BytesIO()\n",
    "    im.save(arr, format=format)\n",
    "    return arr.getvalue()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "---\n",
       "\n",
       "#### Image.to_bytes_format\n",
       "\n",
       ">      Image.to_bytes_format (im:PIL.Image.Image, format='png')\n",
       "\n",
       "Convert to bytes, default to PNG format"
      ],
      "text/plain": [
       "<nbdev.showdoc.BasicMarkdownRenderer>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_doc(Image.Image.to_bytes_format)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "@patch\n",
    "def to_thumb(self:Image.Image, h, w=None):\n",
    "    \"Same as `thumbnail`, but uses a copy\"\n",
    "    if w is None: w=h\n",
    "    im = self.copy()\n",
    "    im.thumbnail((w,h))\n",
    "    return im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "---\n",
       "\n",
       "#### Image.to_thumb\n",
       "\n",
       ">      Image.to_thumb (h, w=None)\n",
       "\n",
       "Same as `thumbnail`, but uses a copy"
      ],
      "text/plain": [
       "<nbdev.showdoc.BasicMarkdownRenderer>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_doc(Image.Image.to_thumb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "@patch\n",
    "def resize_max(x: Image.Image, resample=0, max_px=None, max_h=None, max_w=None):\n",
    "    \"`resize` `x` to `max_px`, or `max_h`, or `max_w`\"\n",
    "    h,w = x.shape\n",
    "    if max_px and x.n_px>max_px: h,w = fastuple(h,w).mul(math.sqrt(max_px/x.n_px))\n",
    "    if max_h and h>max_h: h,w = (max_h    ,max_h*w/h)\n",
    "    if max_w and w>max_w: h,w = (max_w*h/w,max_w    )\n",
    "    return x.reshape(round(h), round(w), resample=resample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.resize_max(max_px=20*30).shape, (20,30))\n",
    "test_eq(im.resize_max(max_px=300).n_px, 294)\n",
    "test_eq(im.resize_max(max_px=500, max_h=10, max_w=20).shape, (10,15))\n",
    "test_eq(im.resize_max(max_h=14, max_w=15).shape, (10,15))\n",
    "test_eq(im.resize_max(max_px=300, max_h=10, max_w=25).shape, (10,15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "---\n",
       "\n",
       "#### Image.resize_max\n",
       "\n",
       ">      Image.resize_max (x:PIL.Image.Image, resample=0, max_px=None, max_h=None,\n",
       ">                        max_w=None)\n",
       "\n",
       "`resize` `x` to `max_px`, or `max_h`, or `max_w`"
      ],
      "text/plain": [
       "<nbdev.showdoc.BasicMarkdownRenderer>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_doc(Image.Image.resize_max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This section regroups the basic types used in vision with the transform that create objects of those types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def to_image(x):\n",
    "    \"Convert a tensor or array to a PIL int8 Image\"\n",
    "    if isinstance(x,Image.Image): return x\n",
    "    if isinstance(x,Tensor): x = to_np(x.permute((1,2,0)))\n",
    "    if x.dtype==np.float32: x = (x*255).astype(np.uint8)\n",
    "    return Image.fromarray(x, mode=['RGB','CMYK'][x.shape[0]==4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def load_image(fn, mode=None):\n",
    "    \"Open and load a `PIL.Image` and convert to `mode`\"\n",
    "    im = Image.open(fn)\n",
    "    im.load()\n",
    "    im = im._new(im.im)\n",
    "    return im.convert(mode) if mode else im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def image2tensor(img):\n",
    "    \"Transform image to byte tensor in `c*h*w` dim order.\"\n",
    "    res = tensor(img)\n",
    "    if res.dim()==2: res = res.unsqueeze(-1)\n",
    "    return res.permute(2,0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class PILBase(Image.Image, metaclass=BypassNewMeta):\n",
    "    \"Base class for a Pillow `Image` that can show itself and convert to a Tensor\"\n",
    "    _bypass_type=Image.Image\n",
    "    _show_args = {'cmap':'viridis'}\n",
    "    _open_args = {'mode': 'RGB'}\n",
    "    @classmethod\n",
    "    def create(cls, fn:Path|str|Tensor|ndarray|bytes|Image.Image, **kwargs):\n",
    "        \"Return an Image from `fn`\"\n",
    "        if isinstance(fn,TensorImage): fn = fn.permute(1,2,0).type(torch.uint8)\n",
    "        if isinstance(fn,TensorMask): fn = fn.type(torch.uint8)\n",
    "        if isinstance(fn,Tensor): fn = fn.numpy()\n",
    "        if isinstance(fn,ndarray): return cls(Image.fromarray(fn))\n",
    "        if isinstance(fn,bytes): fn = io.BytesIO(fn)\n",
    "        if isinstance(fn,Image.Image): return cls(fn)\n",
    "        return cls(load_image(fn, **merge(cls._open_args, kwargs)))\n",
    "\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        \"Show image using `merge(self._show_args, kwargs)`\"\n",
    "        return show_image(self, ctx=ctx, **merge(self._show_args, kwargs))\n",
    "\n",
    "    def __repr__(self): return f'{self.__class__.__name__} mode={self.mode} size={\"x\".join([str(d) for d in self.size])}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "---\n",
       "\n",
       "[source](https://github.com/fastai/fastai/blob/main/fastai/vision/core.py#L119){target=\"_blank\" style=\"float:right; font-size:smaller\"}\n",
       "\n",
       "### PILBase.create\n",
       "\n",
       ">      PILBase.create\n",
       ">                      (fn:pathlib.Path|str|torch.Tensor|numpy.ndarray|bytes|PIL\n",
       ">                      .Image.Image, **kwargs)\n",
       "\n",
       "*Return an Image from `fn`*"
      ],
      "text/plain": [
       "---\n",
       "\n",
       "[source](https://github.com/fastai/fastai/blob/main/fastai/vision/core.py#L119){target=\"_blank\" style=\"float:right; font-size:smaller\"}\n",
       "\n",
       "### PILBase.create\n",
       "\n",
       ">      PILBase.create\n",
       ">                      (fn:pathlib.Path|str|torch.Tensor|numpy.ndarray|bytes|PIL\n",
       ">                      .Image.Image, **kwargs)\n",
       "\n",
       "*Return an Image from `fn`*"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_doc(PILBase.create)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Images passed to `PILBase` or inherited classes' `create` as a PyTorch `Tensor`, NumPy `ndarray`, or Pillow `Image` must already be in the correct Pillow image format. For example, `uint8`, and RGB or BW for `PILImage` or `PILImageBW`, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "---\n",
       "\n",
       "[source](https://github.com/fastai/fastai/blob/main/fastai/vision/core.py#L129){target=\"_blank\" style=\"float:right; font-size:smaller\"}\n",
       "\n",
       "### PILBase.show\n",
       "\n",
       ">      PILBase.show (ctx=None, **kwargs)\n",
       "\n",
       "*Show image using `merge(self._show_args, kwargs)`*"
      ],
      "text/plain": [
       "---\n",
       "\n",
       "[source](https://github.com/fastai/fastai/blob/main/fastai/vision/core.py#L129){target=\"_blank\" style=\"float:right; font-size:smaller\"}\n",
       "\n",
       "### PILBase.show\n",
       "\n",
       ">      PILBase.show (ctx=None, **kwargs)\n",
       "\n",
       "*Show image using `merge(self._show_args, kwargs)`*"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_doc(PILBase.show)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class PILImage(PILBase): \n",
    "    \"A RGB Pillow `Image` that can show itself and converts to `TensorImage`\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class PILImageBW(PILImage):\n",
    "    \"A BW Pillow `Image` that can show itself and converts to `TensorImageBW`\"\n",
    "    _show_args,_open_args = {'cmap':'Greys'},{'mode': 'L'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = PILImage.create(TEST_IMAGE)\n",
    "test_eq(type(im), PILImage)\n",
    "test_eq(im.mode, 'RGB')\n",
    "test_eq(str(im), 'PILImage mode=RGB size=1200x803')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im2 = PILImage.create(im)\n",
    "test_eq(type(im2), PILImage)\n",
    "test_eq(im2.mode, 'RGB')\n",
    "test_eq(str(im2), 'PILImage mode=RGB size=1200x803')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=64x64>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "im.resize((64,64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 72x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = im.show(figsize=(1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_fig_exists(ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timg = TensorImage(image2tensor(im))\n",
    "tpil = PILImage.create(timg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=64x64>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tpil.resize((64,64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| hide\n",
    "test_eq(np.array(im), np.array(tpil))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class PILMask(PILBase):\n",
    "    \"A Pillow `Image` Mask that can show itself and converts to `TensorMask`\"\n",
    "    _open_args,_show_args = {'mode':'L'},{'alpha':0.5, 'cmap':'tab20'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = PILMask.create(TEST_IMAGE)\n",
    "test_eq(type(im), PILMask)\n",
    "test_eq(im.mode, 'L')\n",
    "test_eq(str(im), 'PILMask mode=L size=1200x803')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "OpenMask = Transform(PILMask.create)\n",
    "OpenMask.loss_func = CrossEntropyLossFlat(axis=1)\n",
    "PILMask.create = OpenMask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mnist = untar_data(URLs.MNIST_TINY)\n",
    "fns = get_image_files(mnist)\n",
    "mnist_fn = TEST_IMAGE_BW"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAA4klEQVR4nGNgGEjgu/Xf//gIrFLMiZ/+/v3793cpPxZJkWN/IeC9NUKQCUq/Wfab4fv9VwwMfP7YDM5r3MAQ/Pfv30MSWO2VYgj++/fvXwMMYxkYGBieMTAwMDAceIZVEgLOvsIhmYLVOgYGBgYGx29///5dz4Jdcs3fv3//uuHQ6fT379+/78ywSwo6vvj79+9UVhx6dXv//v1bjUVC8+zZs4pMDX//fk2GCSHcxmnAwLBlnQEDw6cbmDqNoNHy9wpcCBEIj/fhcAjEXKvNv//+/XtbB4d899+/TYb4DKA9AABLQV4KAJgjfgAAAABJRU5ErkJggg==",
      "text/plain": [
       "PILImageBW mode=L size=28x28"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timg = Transform(PILImageBW.create)\n",
    "mnist_img = timg(mnist_fn)\n",
    "test_eq(mnist_img.size, (28,28))\n",
    "assert isinstance(mnist_img, PILImageBW)\n",
    "mnist_img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Segmentation masks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class AddMaskCodes(Transform):\n",
    "    \"Add the code metadata to a `TensorMask`\"\n",
    "    def __init__(self, codes=None):\n",
    "        self.codes = codes\n",
    "        if codes is not None: self.vocab,self.c = codes,len(codes)\n",
    "\n",
    "    def decodes(self, o:TensorMask):\n",
    "        if self.codes is not None: o.codes=self.codes\n",
    "        return o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "camvid = untar_data(URLs.CAMVID_TINY)\n",
    "fns = get_image_files(camvid/'images')\n",
    "cam_fn = fns[0]\n",
    "mask_fn = camvid/'labels'/f'{cam_fn.stem}_P{cam_fn.suffix}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cam_img = PILImage.create(cam_fn)\n",
    "test_eq(cam_img.size, (128,96))\n",
    "tmask = Transform(PILMask.create)\n",
    "mask = tmask(mask_fn)\n",
    "test_eq(type(mask), PILMask)\n",
    "test_eq(mask.size, (128,96))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "_,axs = plt.subplots(1,3, figsize=(12,3))\n",
    "cam_img.show(ctx=axs[0], title='image')\n",
    "mask.show(alpha=1, ctx=axs[1], vmin=1, vmax=30, title='mask')\n",
    "cam_img.show(ctx=axs[2], title='superimposed')\n",
    "mask.show(ctx=axs[2], vmin=1, vmax=30);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class TensorPoint(TensorBase):\n",
    "    \"Basic type for points in an image\"\n",
    "    _show_args = dict(s=10, marker='.', c='r')\n",
    "\n",
    "    @classmethod\n",
    "    def create(cls, t, img_size=None)->None:\n",
    "        \"Convert an array or a list of points `t` to a `Tensor`\"\n",
    "        return cls(tensor(t).view(-1, 2).float(), img_size=img_size)\n",
    "\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        if 'figsize' in kwargs: del kwargs['figsize']\n",
    "        x = self.view(-1,2)\n",
    "        ctx.scatter(x[:, 0], x[:, 1], **{**self._show_args, **kwargs})\n",
    "        return ctx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "TensorPointCreate = Transform(TensorPoint.create)\n",
    "TensorPointCreate.loss_func = MSELossFlat()\n",
    "TensorPoint.create = TensorPointCreate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Points are expected to come as an array/tensor of shape `(n,2)` or as a list of lists with two elements. Unless you change the defaults in `PointScaler` (see later on), coordinates should go from 0 to width/height, with the first one being the column index (so from 0 to width) and the second one being the row index (so from 0 to height).\n",
    "\n",
    ":::{.callout-note}\n",
    "\n",
    "This is different from the usual indexing convention for arrays in numpy or in PyTorch, but it's the way points are expected by matplotlib or the internal functions in PyTorch like `F.grid_sample`.\n",
    "\n",
    ":::"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pnt_img = TensorImage(mnist_img.resize((28,35)))\n",
    "pnts = np.array([[0,0], [0,35], [28,0], [28,35], [9, 17]])\n",
    "tfm = Transform(TensorPoint.create)\n",
    "tpnts = tfm(pnts)\n",
    "test_eq(tpnts.shape, [5,2])\n",
    "test_eq(tpnts.dtype, torch.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 72x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ctx = pnt_img.show(figsize=(1,1), cmap='Greys')\n",
    "tpnts.show(ctx=ctx);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bounding boxes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def get_annotations(fname, prefix=None):\n",
    "    \"Open a COCO style json in `fname` and returns the lists of filenames (with maybe `prefix`) and labelled bboxes.\"\n",
    "    annot_dict = json.load(open(fname))\n",
    "    id2images, id2bboxes, id2cats = {}, collections.defaultdict(list), collections.defaultdict(list)\n",
    "    classes = {o['id']:o['name'] for o in annot_dict['categories']}\n",
    "    for o in annot_dict['annotations']:\n",
    "        bb = o['bbox']\n",
    "        id2bboxes[o['image_id']].append([bb[0],bb[1], bb[0]+bb[2], bb[1]+bb[3]])\n",
    "        id2cats[o['image_id']].append(classes[o['category_id']])\n",
    "    id2images = {o['id']:ifnone(prefix, '') + o['file_name'] for o in annot_dict['images'] if o['id'] in id2bboxes}\n",
    "    ids = list(id2images.keys())\n",
    "    return [id2images[k] for k in ids], [(id2bboxes[k], id2cats[k]) for k in ids]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test `get_annotations` on the coco_tiny dataset against both image filenames and bounding box labels. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coco = untar_data(URLs.COCO_TINY)\n",
    "test_images, test_lbl_bbox = get_annotations(coco/'train.json')\n",
    "annotations = json.load(open(coco/'train.json'))\n",
    "categories, images, annots = map(lambda x:L(x),annotations.values())\n",
    "\n",
    "test_eq(test_images, images.attrgot('file_name'))\n",
    "\n",
    "def bbox_lbls(file_name):\n",
    "    img = images.filter(lambda img:img['file_name']==file_name)[0]\n",
    "    bbs = annots.filter(lambda a:a['image_id'] == img['id'])\n",
    "    i2o = {k['id']:k['name'] for k in categories}\n",
    "    lbls = [i2o[cat] for cat in bbs.attrgot('category_id')]\n",
    "    bboxes = [[bb[0],bb[1], bb[0]+bb[2], bb[1]+bb[3]] for bb in bbs.attrgot('bbox')]\n",
    "    return [bboxes, lbls]\n",
    "\n",
    "for idx in random.sample(range(len(images)),5): \n",
    "    test_eq(test_lbl_bbox[idx], bbox_lbls(test_images[idx]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "from matplotlib import patches, patheffects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def _draw_outline(o, lw):\n",
    "    o.set_path_effects([patheffects.Stroke(linewidth=lw, foreground='black'), patheffects.Normal()])\n",
    "\n",
    "def _draw_rect(ax, b, color='white', text=None, text_size=14, hw=True, rev=False):\n",
    "    lx,ly,w,h = b\n",
    "    if rev: lx,ly,w,h = ly,lx,h,w\n",
    "    if not hw: w,h = w-lx,h-ly\n",
    "    patch = ax.add_patch(patches.Rectangle((lx,ly), w, h, fill=False, edgecolor=color, lw=2))\n",
    "    _draw_outline(patch, 4)\n",
    "    if text is not None:\n",
    "        patch = ax.text(lx,ly, text, verticalalignment='top', color=color, fontsize=text_size, weight='bold')\n",
    "        _draw_outline(patch,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class TensorBBox(TensorPoint):\n",
    "    \"Basic type for a tensor of bounding boxes in an image\"\n",
    "    @classmethod\n",
    "    def create(cls, x, img_size=None)->None: return cls(tensor(x).view(-1, 4).float(), img_size=img_size)\n",
    "\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        x = self.view(-1,4)\n",
    "        for b in x: _draw_rect(ctx, b, hw=False, **kwargs)\n",
    "        return ctx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bounding boxes are expected to come as tuple with an array/tensor of shape `(n,4)` or as a list of lists with four elements and a list of corresponding labels. Unless you change the defaults in `PointScaler` (see later on), coordinates for each bounding box should go from 0 to width/height, with the following convention: x1, y1, x2, y2 where (x1,y1) is your top-left corner and (x2,y2) is your bottom-right corner.\n",
    "\n",
    ":::{.callout-note}\n",
    "\n",
    "We use the same convention as for points with x going from 0 to width and y going from 0 to height.\n",
    "\n",
    ":::"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class LabeledBBox(L):\n",
    "    \"Basic type for a list of bounding boxes in an image\"\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        for b,l in zip(self.bbox, self.lbl):\n",
    "            if l != '#na#': ctx = retain_type(b, self.bbox).show(ctx=ctx, text=l)\n",
    "        return ctx\n",
    "\n",
    "    bbox,lbl = add_props(lambda i,self: self[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coco = untar_data(URLs.COCO_TINY)\n",
    "images, lbl_bbox = get_annotations(coco/'train.json')\n",
    "idx=2\n",
    "coco_fn,bbox = coco/'train'/images[idx],lbl_bbox[idx]\n",
    "coco_img = timg(coco_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tbbox = LabeledBBox(TensorBBox(bbox[0]), bbox[1])\n",
    "ctx = coco_img.show(figsize=(3,3), cmap='Greys')\n",
    "tbbox.show(ctx=ctx);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unless specifically mentioned, all the following transforms can be used as single-item transforms (in one of the list in the `tfms` you pass to a `TfmdDS` or a `Datasource`) or tuple transforms (in the `tuple_tfms` you pass to a `TfmdDS` or a `Datasource`). The safest way that will work across applications is to always use them as `tuple_tfms`. For instance, if you have points or bounding boxes as targets and use `Resize` as a single-item transform, when you get to `PointScaler` (which is a tuple transform) you won't have the correct size of the image to properly scale your points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "PILImage  ._tensor_cls = TensorImage\n",
    "PILImageBW._tensor_cls = TensorImageBW\n",
    "PILMask   ._tensor_cls = TensorMask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "@ToTensor\n",
    "def encodes(self, o:PILBase): return o._tensor_cls(image2tensor(o))\n",
    "@ToTensor\n",
    "def encodes(self, o:PILMask): return o._tensor_cls(image2tensor(o)[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any data augmentation transform that runs on PIL Images must be run before this transform."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ToTensor(enc:2,dec:0)\n",
      "<class '__main__.PILImageBW'>\n",
      "<class 'fastai.torch_core.TensorImageBW'>\n"
     ]
    }
   ],
   "source": [
    "tfm = ToTensor()\n",
    "print(tfm)\n",
    "print(type(mnist_img))\n",
    "print(type(tfm(mnist_img)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfm = ToTensor()\n",
    "test_eq(tfm(mnist_img).shape, (1,28,28))\n",
    "test_eq(type(tfm(mnist_img)), TensorImageBW)\n",
    "test_eq(tfm(mask).shape, (96,128))\n",
    "test_eq(type(tfm(mask)), TensorMask)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's confirm we can pipeline this with `PILImage.create`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 72x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pipe_img = Pipeline([PILImageBW.create, ToTensor()])\n",
    "img = pipe_img(mnist_fn)\n",
    "test_eq(type(img), TensorImageBW)\n",
    "pipe_img.show(img, figsize=(1,1));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 216x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def _cam_lbl(x): return mask_fn\n",
    "cam_tds = Datasets([cam_fn], [[PILImage.create, ToTensor()], [_cam_lbl, PILMask.create, ToTensor()]])\n",
    "show_at(cam_tds, 0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To work with data augmentation, and in particular the `grid_sample` method, points need to be represented with coordinates going from -1 to 1 (-1 being top or left, 1 bottom or right), which will be done unless you pass `do_scale=False`. We also need to make sure they are following our convention of points being x,y coordinates, so pass along `y_first=True` if you have your data in an y,x format to add a flip.\n",
    "\n",
    ":::{.callout-warning}\n",
    "\n",
    "This transform needs to run on the tuple level, before any transform that changes the image size.\n",
    "\n",
    ":::"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def _scale_pnts(y, sz, do_scale=True, y_first=False):\n",
    "    if y_first: y = y.flip(1)\n",
    "    res = y * 2/tensor(sz).float() - 1 if do_scale else y\n",
    "    return TensorPoint(res, img_size=sz)\n",
    "\n",
    "def _unscale_pnts(y, sz): return TensorPoint((y+1) * tensor(sz).float()/2, img_size=sz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class PointScaler(Transform):\n",
    "    \"Scale a tensor representing points\"\n",
    "    order = 1\n",
    "    def __init__(self, do_scale=True, y_first=False): self.do_scale,self.y_first = do_scale,y_first\n",
    "    def _grab_sz(self, x):\n",
    "        self.sz = [x.shape[-1], x.shape[-2]] if isinstance(x, Tensor) else x.size\n",
    "        return x\n",
    "\n",
    "    def _get_sz(self, x): return getattr(x, 'img_size') if self.sz is None else self.sz\n",
    "\n",
    "    def setups(self, dl):\n",
    "        res = first(dl.do_item(None), risinstance(TensorPoint))\n",
    "        if res is not None: self.c = res.numel()\n",
    "\n",
    "    def encodes(self, x:PILBase|TensorImageBase): return self._grab_sz(x)\n",
    "    def decodes(self, x:PILBase|TensorImageBase): return self._grab_sz(x)\n",
    "\n",
    "    def encodes(self, x:TensorPoint): return _scale_pnts(x, self._get_sz(x), self.do_scale, self.y_first)\n",
    "    def decodes(self, x:TensorPoint): return _unscale_pnts(x.view(-1, 2), self._get_sz(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To work with data augmentation, and in particular the `grid_sample` method, points need to be represented with coordinates going from -1 to 1 (-1 being top or left, 1 bottom or right), which will be done unless you pass `do_scale=False`. We also need to make sure they are following our convention of points being x,y coordinates, so pass along `y_first=True` if you have your data in an y,x format to add a flip.\n",
    "\n",
    ":::{.callout-note}\n",
    "\n",
    "This transform automatically grabs the sizes of the images it sees before a <code>TensorPoint</code> object and embeds it in them. For this to work, those images need to be before any points in the order of your final tuple. If you don't have such images, you need to embed the size of the corresponding image when creating a <code>TensorPoint</code> by passing it with `sz=...`.\n",
    "\n",
    ":::"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _pnt_lbl(x): return TensorPoint.create(pnts)\n",
    "def _pnt_open(fn): return PILImage(PILImage.create(fn).resize((28,35)))\n",
    "pnt_tds = Datasets([mnist_fn], [_pnt_open, [_pnt_lbl]])\n",
    "pnt_tdl = TfmdDL(pnt_tds, bs=1, after_item=[PointScaler(), ToTensor()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(pnt_tdl.after_item.c, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| hide\n",
    "#Check the size was grabbed by PointScaler and added to y\n",
    "tfm = PointScaler()\n",
    "tfm.as_item=False\n",
    "x,y = tfm(pnt_tds[0])\n",
    "test_eq(tfm.sz, x.size)\n",
    "test_eq(y.img_size, x.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y = pnt_tdl.one_batch()\n",
    "#Scaling and flipping properly done\n",
    "#NB: we added a point earlier at (9,17); formula below scales to (-1,1) coords\n",
    "test_close(y[0], tensor([[-1., -1.], [-1.,  1.], [1.,  -1.], [1., 1.], [9/14-1, 17/17.5-1]]))\n",
    "a,b = pnt_tdl.decode_batch((x,y))[0]\n",
    "test_eq(b, tensor(pnts).float())\n",
    "#Check types\n",
    "test_eq(type(x), TensorImage)\n",
    "test_eq(type(y), TensorPoint)\n",
    "test_eq(type(a), TensorImage)\n",
    "test_eq(type(b), TensorPoint)\n",
    "test_eq(b.img_size, (28,35)) #Automatically picked the size of the input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pnt_tdl.show_batch(figsize=(2,2), cmap='Greys');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class BBoxLabeler(Transform):\n",
    "    def setups(self, dl): self.vocab = dl.vocab\n",
    "\n",
    "    def decode (self, x, **kwargs):\n",
    "        self.bbox,self.lbls = None,None\n",
    "        return self._call('decodes', x, **kwargs)\n",
    "\n",
    "    def decodes(self, x:TensorMultiCategory):\n",
    "        self.lbls = [self.vocab[a] for a in x]\n",
    "        return x if self.bbox is None else LabeledBBox(self.bbox, self.lbls)\n",
    "\n",
    "    def decodes(self, x:TensorBBox):\n",
    "        self.bbox = x\n",
    "        return self.bbox if self.lbls is None else LabeledBBox(self.bbox, self.lbls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "#LabeledBBox can be sent in a tl with MultiCategorize (depending on the order of the tls) but it is already decoded.\n",
    "@MultiCategorize\n",
    "def decodes(self, x:LabeledBBox): return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "@PointScaler\n",
    "def encodes(self, x:TensorBBox):\n",
    "    pnts = self.encodes(cast(x.view(-1,2), TensorPoint))\n",
    "    return cast(pnts.view(-1, 4), TensorBBox)\n",
    "\n",
    "@PointScaler\n",
    "def decodes(self, x:TensorBBox):\n",
    "    pnts = self.decodes(cast(x.view(-1,2), TensorPoint))\n",
    "    return cast(pnts.view(-1, 4), TensorBBox)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _coco_bb(x):  return TensorBBox.create(bbox[0])\n",
    "def _coco_lbl(x): return bbox[1]\n",
    "\n",
    "coco_tds = Datasets([coco_fn], [PILImage.create, [_coco_bb], [_coco_lbl, MultiCategorize(add_na=True)]], n_inp=1)\n",
    "coco_tdl = TfmdDL(coco_tds, bs=1, after_item=[BBoxLabeler(), PointScaler(), ToTensor()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| hide\n",
    "#Check the size was grabbed by PointScaler and added to y\n",
    "tfm = PointScaler()\n",
    "tfm.as_item=False\n",
    "x,y,z = tfm(coco_tds[0])\n",
    "test_eq(tfm.sz, x.size)\n",
    "test_eq(y.img_size, x.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Categorize -- {'vocab': None, 'sort': True, 'add_na': True}\n",
       "(enc:1,dec:1)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Categorize(add_na=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(#3) [Pipeline: PILBase.create,Pipeline: _coco_bb,Pipeline: _coco_lbl -> MultiCategorize -- {'vocab': None, 'sort': True, 'add_na': True}]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coco_tds.tfms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(PILImage mode=RGB size=128x128,\n",
       " TensorBBox([[-0.9011, -0.4606,  0.1416,  0.6764],\n",
       "             [ 0.2000, -0.2405,  1.0000,  0.9102],\n",
       "             [ 0.4909, -0.9325,  0.9284, -0.5011]]),\n",
       " TensorMultiCategory([1, 1, 1]))"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x,y,z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y,z = coco_tdl.one_batch()\n",
    "test_close(y[0], -1+tensor(bbox[0])/64)\n",
    "test_eq(z[0], tensor([1,1,1]))\n",
    "a,b,c = coco_tdl.decode_batch((x,y,z))[0]\n",
    "test_close(b, tensor(bbox[0]).float())\n",
    "test_eq(c.bbox, b)\n",
    "test_eq(c.lbl, bbox[1])\n",
    "\n",
    "#Check types\n",
    "test_eq(type(x), TensorImage)\n",
    "test_eq(type(y), TensorBBox)\n",
    "test_eq(type(z), TensorMultiCategory)\n",
    "test_eq(type(a), TensorImage)\n",
    "test_eq(type(b), TensorBBox)\n",
    "test_eq(type(c), LabeledBBox)\n",
    "test_eq(y.img_size, (128,128))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "coco_tdl.show_batch();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| hide\n",
    "#test other direction works too\n",
    "coco_tds = Datasets([coco_fn], [PILImage.create, [_coco_lbl, MultiCategorize(add_na=True)], [_coco_bb]])\n",
    "coco_tdl = TfmdDL(coco_tds, bs=1, after_item=[BBoxLabeler(), PointScaler(), ToTensor()])\n",
    "\n",
    "x,y,z = coco_tdl.one_batch()\n",
    "test_close(z[0], -1+tensor(bbox[0])/64)\n",
    "test_eq(y[0], tensor([1,1,1]))\n",
    "a,b,c = coco_tdl.decode_batch((x,y,z))[0]\n",
    "test_eq(b, bbox[1])\n",
    "test_close(c.bbox, tensor(bbox[0]).float())\n",
    "test_eq(c.lbl, b)\n",
    "\n",
    "#Check types\n",
    "test_eq(type(x), TensorImage)\n",
    "test_eq(type(y), TensorMultiCategory)\n",
    "test_eq(type(z), TensorBBox)\n",
    "test_eq(type(a), TensorImage)\n",
    "test_eq(type(b), MultiCategory)\n",
    "test_eq(type(c), LabeledBBox)\n",
    "test_eq(z.img_size, (128,128))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Export -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| hide\n",
    "from nbdev import nbdev_export\n",
    "nbdev_export()"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "split_at_heading": true
  },
  "kernelspec": {
   "display_name": "python3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
